package models

import (
	"net"
	"sync"
	"time"
)

// 连接状态
type ConnectionStatus int

const (
	ConnStatusConnecting   ConnectionStatus = iota // 连接中
	ConnStatusConnected                            // 已连接
	ConnStatusDisconnected                         // 已断开
	ConnStatusError                                // 错误状态
)

// 连接类型
type ConnectionType int

const (
	ConnTypeClient   ConnectionType = iota // 客户端连接
	ConnTypeExternal                       // 外部连接
)

// 服务连接信息 (用于内网客户端到服务器的连接)
type ServiceConnection struct {
	ID          uint32           `json:"id"`           // 连接ID
	ServiceName string           `json:"service_name"` // 服务名称
	ServerPort  int              `json:"server_port"`  // 服务器端口
	Conn        net.Conn         `json:"-"`            // 网络连接
	Status      ConnectionStatus `json:"status"`       // 连接状态
	ConnectedAt time.Time        `json:"connected_at"` // 连接时间
	LastActive  time.Time        `json:"last_active"`  // 最后活跃时间

	// 目标服务信息
	TargetHost string `json:"target_host"` // 目标主机
	TargetPort int    `json:"target_port"` // 目标端口
	Protocol   string `json:"protocol"`    // 协议类型

	// 认证信息
	Authenticated bool   `json:"authenticated"` // 是否已认证
	AuthToken     string `json:"auth_token"`    // 认证令牌

	// 统计信息
	BytesSent     uint64 `json:"bytes_sent"`     // 发送字节数
	BytesReceived uint64 `json:"bytes_received"` // 接收字节数

	// 代理连接映射 (外部连接ID -> 代理连接)
	ProxyConnections map[uint32]*ProxyConnection `json:"-"`

	// 并发控制
	mutex sync.RWMutex `json:"-"`
}

// 代理连接信息 (外部客户端到服务器的连接)
type ProxyConnection struct {
	ID          uint32           `json:"id"`           // 连接ID
	Conn        net.Conn         `json:"-"`            // 网络连接
	Status      ConnectionStatus `json:"status"`       // 连接状态
	ConnectedAt time.Time        `json:"connected_at"` // 连接时间
	LastActive  time.Time        `json:"last_active"`  // 最后活跃时间
	RemoteAddr  string           `json:"remote_addr"`  // 远程地址

	// 关联的服务连接
	ServiceConnID uint32 `json:"service_conn_id"` // 服务连接ID
	ServiceName   string `json:"service_name"`    // 服务名称
	ServerPort    int    `json:"server_port"`     // 服务器端口

	// 认证信息
	Authenticated bool   `json:"authenticated"` // 是否已认证
	AuthToken     string `json:"auth_token"`    // 认证令牌

	// 统计信息
	BytesSent     uint64 `json:"bytes_sent"`     // 发送字节数
	BytesReceived uint64 `json:"bytes_received"` // 接收字节数

	// 并发控制
	mutex sync.RWMutex `json:"-"`
}

// 客户端连接组 (同一个客户端的所有服务连接)
type ClientConnectionGroup struct {
	ClientID    string                        `json:"client_id"`    // 客户端ID
	ClientAddr  string                        `json:"client_addr"`  // 客户端地址
	ConnectedAt time.Time                     `json:"connected_at"` // 首次连接时间
	LastActive  time.Time                     `json:"last_active"`  // 最后活跃时间
	Services    map[string]*ServiceConnection `json:"services"`     // 服务连接映射 (服务名 -> 连接)

	// 统计信息
	TotalBytesSent     uint64 `json:"total_bytes_sent"`     // 总发送字节数
	TotalBytesReceived uint64 `json:"total_bytes_received"` // 总接收字节数

	// 并发控制
	mutex sync.RWMutex `json:"-"`
}

// 连接统计信息
type ConnectionStats struct {
	// 服务连接统计
	TotalServiceConnections  int `json:"total_service_connections"`  // 总服务连接数
	ActiveServiceConnections int `json:"active_service_connections"` // 活跃服务连接数

	// 代理连接统计
	TotalProxyConnections  int `json:"total_proxy_connections"`  // 总代理连接数
	ActiveProxyConnections int `json:"active_proxy_connections"` // 活跃代理连接数

	// 客户端组统计
	TotalClientGroups  int `json:"total_client_groups"`  // 总客户端组数
	ActiveClientGroups int `json:"active_client_groups"` // 活跃客户端组数

	// 服务统计 (按服务名分组)
	ServiceStats map[string]*ServiceStats `json:"service_stats"`

	// 流量统计
	TotalBytesSent     uint64 `json:"total_bytes_sent"`     // 总发送字节数
	TotalBytesReceived uint64 `json:"total_bytes_received"` // 总接收字节数

	// 性能统计
	AverageLatency time.Duration `json:"average_latency"` // 平均延迟
	ConnectionRate float64       `json:"connection_rate"` // 连接率 (连接/秒)
}

// 服务统计信息
type ServiceStats struct {
	ServiceName       string    `json:"service_name"`       // 服务名称
	ServerPort        int       `json:"server_port"`        // 服务器端口
	ActiveConnections int       `json:"active_connections"` // 活跃连接数
	TotalConnections  int       `json:"total_connections"`  // 总连接数
	BytesSent         uint64    `json:"bytes_sent"`         // 发送字节数
	BytesReceived     uint64    `json:"bytes_received"`     // 接收字节数
	LastActive        time.Time `json:"last_active"`        // 最后活跃时间
}

// NewServiceConnection 创建新的服务连接
func NewServiceConnection(id uint32, serviceName string, serverPort int, conn net.Conn) *ServiceConnection {
	now := time.Now()
	return &ServiceConnection{
		ID:               id,
		ServiceName:      serviceName,
		ServerPort:       serverPort,
		Conn:             conn,
		Status:           ConnStatusConnected,
		ConnectedAt:      now,
		LastActive:       now,
		ProxyConnections: make(map[uint32]*ProxyConnection),
	}
}

// NewProxyConnection 创建新的代理连接
func NewProxyConnection(id uint32, conn net.Conn, serviceConnID uint32, serviceName string, serverPort int) *ProxyConnection {
	now := time.Now()
	return &ProxyConnection{
		ID:            id,
		Conn:          conn,
		Status:        ConnStatusConnected,
		ConnectedAt:   now,
		LastActive:    now,
		RemoteAddr:    conn.RemoteAddr().String(),
		ServiceConnID: serviceConnID,
		ServiceName:   serviceName,
		ServerPort:    serverPort,
	}
}

// NewClientConnectionGroup 创建新的客户端连接组
func NewClientConnectionGroup(clientID, clientAddr string) *ClientConnectionGroup {
	now := time.Now()
	return &ClientConnectionGroup{
		ClientID:    clientID,
		ClientAddr:  clientAddr,
		ConnectedAt: now,
		LastActive:  now,
		Services:    make(map[string]*ServiceConnection),
	}
}

// AddServiceConnection 添加服务连接到客户端组
func (g *ClientConnectionGroup) AddServiceConnection(conn *ServiceConnection) {
	g.mutex.Lock()
	defer g.mutex.Unlock()
	g.Services[conn.ServiceName] = conn
	g.LastActive = time.Now()
}

// RemoveServiceConnection 从客户端组移除服务连接
func (g *ClientConnectionGroup) RemoveServiceConnection(serviceName string) {
	g.mutex.Lock()
	defer g.mutex.Unlock()
	delete(g.Services, serviceName)
	g.LastActive = time.Now()
}

// GetServiceConnection 获取指定服务的连接
func (g *ClientConnectionGroup) GetServiceConnection(serviceName string) (*ServiceConnection, bool) {
	g.mutex.RLock()
	defer g.mutex.RUnlock()
	conn, exists := g.Services[serviceName]
	return conn, exists
}

// AddProxyConnection 添加代理连接到服务连接
func (s *ServiceConnection) AddProxyConnection(proxyConn *ProxyConnection) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.ProxyConnections[proxyConn.ID] = proxyConn
	s.LastActive = time.Now()
}

// RemoveProxyConnection 从服务连接移除代理连接
func (s *ServiceConnection) RemoveProxyConnection(proxyID uint32) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	delete(s.ProxyConnections, proxyID)
	s.LastActive = time.Now()
}

// GetProxyConnection 获取指定的代理连接
func (s *ServiceConnection) GetProxyConnection(proxyID uint32) (*ProxyConnection, bool) {
	s.mutex.RLock()
	defer s.mutex.RUnlock()
	conn, exists := s.ProxyConnections[proxyID]
	return conn, exists
}

// UpdateActivity 更新服务连接活跃时间
func (s *ServiceConnection) UpdateActivity() {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.LastActive = time.Now()
}

// AddBytesSent 增加服务连接发送字节数
func (s *ServiceConnection) AddBytesSent(bytes uint64) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.BytesSent += bytes
	s.LastActive = time.Now()
}

// AddBytesReceived 增加服务连接接收字节数
func (s *ServiceConnection) AddBytesReceived(bytes uint64) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.BytesReceived += bytes
	s.LastActive = time.Now()
}

// SetStatus 设置服务连接状态
func (s *ServiceConnection) SetStatus(status ConnectionStatus) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.Status = status
}

// IsActive 检查服务连接是否活跃
func (s *ServiceConnection) IsActive(timeout time.Duration) bool {
	s.mutex.RLock()
	defer s.mutex.RUnlock()
	return time.Since(s.LastActive) < timeout
}

// Close 关闭服务连接
func (s *ServiceConnection) Close() error {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	// 关闭所有代理连接
	for _, proxyConn := range s.ProxyConnections {
		proxyConn.Close()
	}
	s.ProxyConnections = make(map[uint32]*ProxyConnection)

	s.Status = ConnStatusDisconnected
	if s.Conn != nil {
		return s.Conn.Close()
	}
	return nil
}

// UpdateActivity 更新代理连接活跃时间
func (p *ProxyConnection) UpdateActivity() {
	p.mutex.Lock()
	defer p.mutex.Unlock()
	p.LastActive = time.Now()
}

// AddBytesSent 增加代理连接发送字节数
func (p *ProxyConnection) AddBytesSent(bytes uint64) {
	p.mutex.Lock()
	defer p.mutex.Unlock()
	p.BytesSent += bytes
	p.LastActive = time.Now()
}

// AddBytesReceived 增加代理连接接收字节数
func (p *ProxyConnection) AddBytesReceived(bytes uint64) {
	p.mutex.Lock()
	defer p.mutex.Unlock()
	p.BytesReceived += bytes
	p.LastActive = time.Now()
}

// SetStatus 设置代理连接状态
func (p *ProxyConnection) SetStatus(status ConnectionStatus) {
	p.mutex.Lock()
	defer p.mutex.Unlock()
	p.Status = status
}

// IsActive 检查代理连接是否活跃
func (p *ProxyConnection) IsActive(timeout time.Duration) bool {
	p.mutex.RLock()
	defer p.mutex.RUnlock()
	return time.Since(p.LastActive) < timeout
}

// Close 关闭代理连接
func (p *ProxyConnection) Close() error {
	p.mutex.Lock()
	defer p.mutex.Unlock()
	p.Status = ConnStatusDisconnected
	if p.Conn != nil {
		return p.Conn.Close()
	}
	return nil
}

// String 返回连接状态的字符串表示
func (s ConnectionStatus) String() string {
	switch s {
	case ConnStatusConnecting:
		return "Connecting"
	case ConnStatusConnected:
		return "Connected"
	case ConnStatusDisconnected:
		return "Disconnected"
	case ConnStatusError:
		return "Error"
	default:
		return "Unknown"
	}
}

// String 返回连接类型的字符串表示
func (t ConnectionType) String() string {
	switch t {
	case ConnTypeClient:
		return "Client"
	case ConnTypeExternal:
		return "External"
	default:
		return "Unknown"
	}
}
